// /* Includes ------------------------------------------------------------------*/
// #include "app_adc.h"
// #include <string.h>
// #include <math.h>



// // 全局ADC应用层实例
// ADC_MultiChannel_App_t g_adc_app;

// // 电压缓冲区
// static float voltage_buffer[3] = {0};

// // 平均值缓冲区
// static float average_buffer[3] = {0};

// // 滤波缓冲区
// static float filter_buffer[3][ADC_FILTER_SAMPLES] = {0};
// static uint8_t filter_index[3] = {0};



// static void ADC_App_UpdateFilter(ADC_MultiChannel_App_t* multi_adc, uint8_t channel_index, float new_value);
// static float ADC_App_CalculateAverage(float* buffer, uint8_t samples);


// /**
//  * @brief 初始化ADC应用层
//  * @param adc_app: ADC应用层结构体指针
//  * @param hadc: ADC句柄指针
//  * @param channel: ADC通道
//  */
// void ADC_App_Init(ADC_App_t* adc_app, ADC_HandleTypeDef* hadc, uint32_t channel) {
//     if (adc_app == NULL || hadc == NULL) {
//         return;
//     }
    
//     memset(adc_app, 0, sizeof(ADC_App_t));
    
//     adc_app->hadc = hadc;
//     adc_app->channel = channel;
//     adc_app->raw_value = 0;
//     adc_app->voltage = 0.0f;
//     adc_app->physical_value = 0.0f;
//     adc_app->is_valid = false;
//     adc_app->calibration_offset = 0.0f;
//     adc_app->calibration_gain = 1.0f;
//     adc_app->sample_count = 0;
//     adc_app->average_value = 0.0f;
// }

// /**
//  * @brief 读取ADC原始值
//  * @param adc_app: ADC应用层结构体指针
//  * @retval ADC原始值
//  */
// uint16_t ADC_App_ReadRaw(ADC_App_t* adc_app) {
//     if (adc_app == NULL || adc_app->hadc == NULL) {
//         return 0;
//     }
    
//     ADC_ChannelConfTypeDef sConfig = {0};
    
//     // 配置ADC通道
//     sConfig.Channel = adc_app->channel;
//     sConfig.Rank = ADC_REGULAR_RANK_1;
//     sConfig.SamplingTime = ADC_SAMPLETIME_71CYCLES_5;
//     sConfig.SingleDiff = ADC_SINGLE_ENDED;
//     sConfig.OffsetNumber = ADC_OFFSET_NONE;
//     sConfig.Offset = 0;
    
//     if (HAL_ADC_ConfigChannel(adc_app->hadc, &sConfig) != HAL_OK) {
//         adc_app->is_valid = false;
//         return 0;
//     }
    
//     // 启动ADC转换
//     HAL_ADC_Start(adc_app->hadc);
//     HAL_ADC_PollForConversion(adc_app->hadc, HAL_MAX_DELAY);
//     adc_app->raw_value = HAL_ADC_GetValue(adc_app->hadc);
//     HAL_ADC_Stop(adc_app->hadc);
    
//     adc_app->is_valid = true;
//     adc_app->sample_count++;
    
//     return adc_app->raw_value;
// }

// /**
//  * @brief 读取ADC电压值
//  * @param adc_app: ADC应用层结构体指针
//  * @retval 电压值(V)
//  */
// float ADC_App_ReadVoltage(ADC_App_t* adc_app) {
//     if (adc_app == NULL) {
//         return 0.0f;
//     }
    
//     if (!adc_app->is_valid) {
//         ADC_App_ReadRaw(adc_app);
//     }
    
//     // 12位ADC，参考电压3.3V
//     adc_app->voltage = ADC_TO_VOLTAGE(adc_app->raw_value);
//     return adc_app->voltage;
// }

// /**
//  * @brief 设置ADC校准参数
//  * @param adc_app: ADC应用层结构体指针
//  * @param offset: 偏移量
//  * @param gain: 增益
//  */
// void ADC_App_SetCalibration(ADC_App_t* adc_app, float offset, float gain) {
//     if (adc_app == NULL) {
//         return;
//     }
    
//     adc_app->calibration_offset = offset;
//     adc_app->calibration_gain = gain;
// }

// /**
//  * @brief 读取物理量值（经过校准）
//  * @param adc_app: ADC应用层结构体指针
//  * @retval 物理量值
//  */
// float ADC_App_ReadPhysicalValue(ADC_App_t* adc_app) {
//     if (adc_app == NULL) {
//         return 0.0f;
//     }
    
//     float voltage = ADC_App_ReadVoltage(adc_app);
//     adc_app->physical_value = voltage * adc_app->calibration_gain + adc_app->calibration_offset;
//     return adc_app->physical_value;
// }

// /**
//  * @brief ADC数据滤波（滑动平均）
//  * @param adc_app: ADC应用层结构体指针
//  * @param new_value: 新采样值
//  * @retval 滤波后的值
//  */
// float ADC_App_Filter(ADC_App_t* adc_app, float new_value) {
//     if (adc_app == NULL) {
//         return 0.0f;
//     }
    
//     // 简单的滑动平均滤波
//     adc_app->average_value = (adc_app->average_value * 0.9f) + (new_value * 0.1f);
//     return adc_app->average_value;
// }

// /**
//  * @brief 初始化多通道ADC应用层
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  * @param hadc: ADC句柄指针
//  * @param raw_buffer: 原始数据缓冲区
//  * @param voltage_buffer: 电压数据缓冲区
//  * @param channel_count: 通道数量
//  */
// void ADC_MultiChannel_App_Init(ADC_MultiChannel_App_t* multi_adc, 
//                               ADC_HandleTypeDef* hadc, 
//                               uint16_t* raw_buffer, 
//                               float* voltage_buffer, 
//                               uint8_t channel_count) {
//     if (multi_adc == NULL || hadc == NULL || raw_buffer == NULL || voltage_buffer == NULL) {
//         return;
//     }
    
//     memset(multi_adc, 0, sizeof(ADC_MultiChannel_App_t));
    
//     multi_adc->hadc = hadc;
//     multi_adc->raw_buffer = raw_buffer;
//     multi_adc->voltage_buffer = voltage_buffer;
//     multi_adc->channel_count = channel_count;
//     multi_adc->is_valid = false;
//     multi_adc->dma_enabled = false;
//     multi_adc->conversion_count = 0;
//     multi_adc->average_buffer = average_buffer;
//     multi_adc->filter_samples = ADC_FILTER_SAMPLES;
    
//     // 初始化滤波缓冲区
//     for (uint8_t i = 0; i < channel_count; i++) {
//         filter_index[i] = 0;
//         for (uint8_t j = 0; j < ADC_FILTER_SAMPLES; j++) {
//             filter_buffer[i][j] = 0.0f;
//         }
//     }
// }

// /**
//  * @brief 处理多通道ADC数据
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  */
// void ADC_MultiChannel_App_Process(ADC_MultiChannel_App_t* multi_adc) {
//     if (multi_adc == NULL || !multi_adc->is_valid) {
//         return;
//     }
    
//     // 将原始ADC值转换为电压值
//     for (uint8_t i = 0; i < multi_adc->channel_count; i++) {
//         multi_adc->voltage_buffer[i] = ADC_TO_VOLTAGE(multi_adc->raw_buffer[i]);
        
//         // 更新滤波缓冲区
//         ADC_App_UpdateFilter(multi_adc, i, multi_adc->voltage_buffer[i]);
        
//         // 计算平均值
//         multi_adc->average_buffer[i] = ADC_App_CalculateAverage(filter_buffer[i], ADC_FILTER_SAMPLES);
//     }
    
//     multi_adc->conversion_count++;
// }

// /**
//  * @brief 启动多通道ADC DMA传输
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  * @retval HAL状态
//  */
// HAL_StatusTypeDef ADC_MultiChannel_App_StartDMA(ADC_MultiChannel_App_t* multi_adc) {
//     if (multi_adc == NULL || multi_adc->hadc == NULL) {
//         return HAL_ERROR;
//     }
    
//     HAL_StatusTypeDef status = HAL_ADC_Start_DMA(multi_adc->hadc, 
//                                                 (uint32_t*)multi_adc->raw_buffer, 
//                                                 multi_adc->channel_count);
    
//     if (status == HAL_OK) {
//         multi_adc->dma_enabled = true;
//     }
    
//     return status;
// }

// /**
//  * @brief 停止多通道ADC DMA传输
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  * @retval HAL状态
//  */
// HAL_StatusTypeDef ADC_MultiChannel_App_StopDMA(ADC_MultiChannel_App_t* multi_adc) {
//     if (multi_adc == NULL || multi_adc->hadc == NULL) {
//         return HAL_ERROR;
//     }
    
//     HAL_StatusTypeDef status = HAL_ADC_Stop_DMA(multi_adc->hadc);
    
//     if (status == HAL_OK) {
//         multi_adc->dma_enabled = false;
//     }
    
//     return status;
// }

// /**
//  * @brief 获取指定通道的电压值
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  * @param channel_index: 通道索引
//  * @retval 电压值
//  */
// float ADC_MultiChannel_App_GetVoltage(ADC_MultiChannel_App_t* multi_adc, uint8_t channel_index) {
//     if (multi_adc == NULL || channel_index >= multi_adc->channel_count) {
//         return 0.0f;
//     }
    
//     return multi_adc->voltage_buffer[channel_index];
// }

// /**
//  * @brief 获取指定通道的原始值
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  * @param channel_index: 通道索引
//  * @retval 原始ADC值
//  */
// uint16_t ADC_MultiChannel_App_GetRaw(ADC_MultiChannel_App_t* multi_adc, uint8_t channel_index) {
//     if (multi_adc == NULL || channel_index >= multi_adc->channel_count) {
//         return 0;
//     }
    
//     return multi_adc->raw_buffer[channel_index];
// }

// /**
//  * @brief ADC转换完成回调函数
//  * @param hadc: ADC句柄指针
//  */
// void ADC_App_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
//     if (hadc == NULL) {
//         return;
//     }
    
//     if (hadc->Instance == ADC5) {
//         // ADC5转换完成，设置数据有效标志
//         g_adc_app.is_valid = true;
//     }
// }

// /**
//  * @brief ADC错误回调函数
//  * @param hadc: ADC句柄指针
//  */
// void ADC_App_ErrorCallback(ADC_HandleTypeDef* hadc) {
//     if (hadc == NULL) {
//         return;
//     }
    
//     // 处理ADC错误
//     if (hadc->Instance == ADC5) {
//         g_adc_app.is_valid = false;
//         // 可以在这里添加错误处理逻辑
//     }
// }

// /**
//  * @brief 全局ADC应用层初始化
//  */
// void ADC_App_GlobalInit(void) {
//     // 初始化全局ADC应用层
//     ADC_MultiChannel_App_Init(&g_adc_app, &hadc5, adc, voltage_buffer, 3);
    
//     // 启动DMA传输
//     ADC_MultiChannel_App_StartDMA(&g_adc_app);
// }

// /**
//  * @brief 全局ADC应用层处理
//  */
// void ADC_App_GlobalProcess(void) {
//     // 处理ADC数据
//     ADC_MultiChannel_App_Process(&g_adc_app);
// }

// /* USER CODE END 0 */

// /* Private functions ---------------------------------------------------------*/
// /* USER CODE BEGIN 1 */

// /**
//  * @brief 更新滤波缓冲区
//  * @param multi_adc: 多通道ADC应用层结构体指针
//  * @param channel_index: 通道索引
//  * @param new_value: 新值
//  */
// static void ADC_App_UpdateFilter(ADC_MultiChannel_App_t* multi_adc, uint8_t channel_index, float new_value) {
//     if (multi_adc == NULL || channel_index >= multi_adc->channel_count) {
//         return;
//     }
    
//     // 更新滤波缓冲区
//     filter_buffer[channel_index][filter_index[channel_index]] = new_value;
//     filter_index[channel_index] = (filter_index[channel_index] + 1) % ADC_FILTER_SAMPLES;
// }

// /**
//  * @brief 计算平均值
//  * @param buffer: 数据缓冲区
//  * @param samples: 采样数
//  * @retval 平均值
//  */
// static float ADC_App_CalculateAverage(float* buffer, uint8_t samples) {
//     if (buffer == NULL || samples == 0) {
//         return 0.0f;
//     }
    
//     float sum = 0.0f;
//     for (uint8_t i = 0; i < samples; i++) {
//         sum += buffer[i];
//     }
    
//     return sum / samples;
// }

// /* USER CODE END 1 */
